@RestController
class UserController(
    private val userService: UserService,
    private val subscriptionService: SubscriptionService
) {

  @Authenticate
  @PatchMapping("/users/{id}")
  fun updateUserInfo(
    @PathVariable id: Int,
    @RequestBody request: UserUpdateReq,
  ): R<User> {
    val initiator = RequestContext.getUserId()!!
    return R.succeed(userService.updateUserInfo(id, initiator, request))
  }
  
}

@DisplayName("用户参数验证")
@ControllerTest(UserController::class)
class UserControllerTest {

  @Autowired
  private lateinit var mockMvc: MockMvc

  @MockkBean
  private lateinit var subscriptionService: SubscriptionService

  @MockkBean(relaxed = true)
  private lateinit var userService: UserService

  // 同时需要验证鉴权和响应格式
  @Nested
  @DisplayName("更新用户信息")
  inner class UpdateUserInfo : AuthenticateTest, ResponseFormatTest {

    // 指定接口路径
    override val path: String = "/users/1"

    // 指定接口的method和contentType等公共属性
    override fun mockRequest(block: MockHttpServletRequestDsl.() -> Unit): ResultActionsDsl {
      return mockMvc.patch(path) {
        contentType = MediaType.APPLICATION_JSON
        block(this)
      }
    }

    // 异常case的测试
    @ParameterizedTest(name = "{displayName} {argumentsWithNames}")
    @CsvSource(
      value = [
        "'', '', null",
        "' ', null, 非空"
      ],
      nullValues = ["null"]
    )
    fun `400 when illegal input`(name: String?, avatar: String?, description: String?) {
      mockRequestWithToken {
        val mockBody = UserUpdateReq().apply {
          this.name = name
          this.avatar = avatar
          this.description = description
        }
        content = mockBody.toJsonString()
      }.andExpect {
        status { isBadRequest() }
      }
    }

    // 正常case的测试
    @ParameterizedTest(name = "{displayName} {argumentsWithNames}")
    @CsvSource(
      value = [
        "null, null, null",
        "null, null, 非空"
      ],
      nullValues = ["null"]
    )
    fun `200 when legal input`(name: String?, avatar: String?, description: String?) {
      mockRequestWithToken {
        val mockBody = UserUpdateReq().apply {
          this.name = name
          this.avatar = avatar
          this.description = description
        }
        content = mockBody.toJsonString()
      }.andExpect {
        status { isOk() }
      }
    }

  }
}

@ParameterizedTest(name = "{displayName} {argumentsWithNames}")
@MethodSource("com.project5e.app.mylog.controller.mock.ResourceProvider#provideLegalResource")
fun `200 when legal resource`(type: String, comment: String, content: String) {
  every { resourceService.saveV2(any()) } returns listOf()
  mockRequestWithToken {
    this.content = content
  }.andExpect {
    status { isOk() }
  }
}

@ParameterizedTest(name = "{displayName} {argumentsWithNames}")
@MethodSource("com.project5e.app.mylog.controller.mock.ResourceProvider#provideIllegalResource")
fun `400 when illegal resource`(type: String, comment: String, errorKeyWords: List<String>, content: String) {
  val mvcResult = mockRequestWithToken {
    this.content = content
  }.andExpect {
    status { isBadRequest() }
  }.andReturn()

  errorKeyWords.forEach { errorKeyWord ->
                         assertThat(mvcResult.response.contentAsString).contains(errorKeyWord)
                        }
}

object ResourceProvider {

    private const val RESOURCE_FILE_SUFFIX = "json"
    private const val LEGAL_RESOURCE_PATTERN = "classpath:mock-resource/legal/*.$RESOURCE_FILE_SUFFIX"
    private const val ILLEGAL_RESOURCE_PATTERN = "classpath:mock-resource/illegal/*.$RESOURCE_FILE_SUFFIX"

    private const val COMMENT_KEY = "_comment_"
    private const val ERROR_KEYWORDS_KEY = "_errorKeywords_"

    @JvmStatic
    fun provideLegalResource(): List<Arguments> {
        return PathMatchingResourcePatternResolver().getResources(LEGAL_RESOURCE_PATTERN).map { resource ->
            resource.file.name to publicObjectMapper.readTree(resource.file)
        }.map { (fileName, mockResources) ->
            mockResources.map { mockResource ->
                val resourceType = fileName.removeSuffix(RESOURCE_FILE_SUFFIX)
                val comment = (mockResource as ObjectNode).remove(COMMENT_KEY).asText()
                val content = """{"resources": [${mockResource.toJsonString()}]}"""
                Arguments.of(resourceType, comment, content)
            }
        }.flatten()
    }

    @JvmStatic
    fun provideIllegalResource(): List<Arguments> {
        return PathMatchingResourcePatternResolver().getResources(ILLEGAL_RESOURCE_PATTERN).map { resource ->
            resource.file.name to publicObjectMapper.readTree(resource.file)
        }.map { (fileName, mockResources) ->
            mockResources.map { it as ObjectNode }.map { mockResource ->
                val resourceType = fileName.removeSuffix(RESOURCE_FILE_SUFFIX)
                val comment = mockResource.remove(COMMENT_KEY).asText()
                val errorKeywords = mockResource.remove(ERROR_KEYWORDS_KEY).map { it.asText() }
                val content = """{"resources": [${mockResource.toJsonString()}]}"""
                Arguments.of(resourceType, comment, errorKeywords, content)
            }
        }.flatten()
    }
}

@Service
class UserService(@Autowired private val userDao: UserDao) {

  @Value("\${user.appid}")
  lateinit var appId: String

  @Value("\${user.fresh.avatar}")
  lateinit var freshUserAvatar: String

  @GrpcClient("user-service")
  lateinit var userStub: UserServiceGrpc.UserServiceBlockingStub

  fun updateUserInfo(id: Int, initiator: Int, request: UserUpdateReq): User {
    if (id != initiator) {
      throw ResponseException(ResErrCode.ILLEGAL_REQUEST, "不可修改他人信息")
    }
    if (!request.isAllFieldNull()) {
      userDao.updateUserInfo(id, request)
    }
    return getUserInfo(id)
  }
}

@ExtendWith(MockKExtension::class)
open class UserServiceTest {

    @RelaxedMockK
    protected lateinit var userDao: UserDao

    @InjectMockKs
    protected lateinit var userService: UserService

    @BeforeEach
    @Order(Int.MIN_VALUE)
    fun setUp() {
        userService.appId = MOCK_APP_ID
        userService.freshUserAvatar = MOCK_FRESH_USER_AVATAR
        userService.userStub = mockk(relaxed = true)
    }

}

@DisplayName("UserService测试 > 更新用户信息")
class UpdateUserInfoTest : UserServiceTest() {

    @Test
    fun `reject when update others info`() {
        val mockUserId = MOCK_USER_ID
        val mockInitiatorId = MOCK_USER_ID + 1
        val mockRequest = UserUpdateReq()

        assertThat { userService.updateUserInfo(mockUserId, mockInitiatorId, mockRequest) }.isFailure()
            .isInstanceOf(ResponseException::class)
            .matchesPredicate { it.errorCode == ResErrCode.ILLEGAL_REQUEST }
    }

    @Test
    fun `success when empty request`() {
        val spyUserService = spyk(userService)
        every { spyUserService.getUserInfo(any()) } returns User()

        spyUserService.updateUserInfo(MOCK_USER_ID, MOCK_USER_ID, UserUpdateReq())

        verify { userDao wasNot called }
    }

    @Test
    fun `success when non-empty request`() {
        val mockUserId = MOCK_USER_ID
        val mockInitiatorId = MOCK_USER_ID
        val mockRequest = UserUpdateReq().apply {
            this.name = "假名，只让它非空"
        }
        val spyUserService = spyk(userService)
        val mockUpdateResult = User()

        every { spyUserService.getUserInfo(any()) } returns mockUpdateResult

        val updateResult = spyUserService.updateUserInfo(mockUserId, mockInitiatorId, mockRequest)

        val idSlot = slot<Int>()
        val requestSlot = slot<UserUpdateReq>()
        verify { userDao.updateUserInfo(capture(idSlot), capture(requestSlot)) }
        assertThat(idSlot.captured).isEqualTo(mockUserId)
        assertThat(requestSlot.captured).isEqualTo(mockRequest)
        assertThat(updateResult).isEqualTo(mockUpdateResult)
    }

}

fun getInvitationInfo(): InvitationInfoResponseDto {
      val currentUser = RequestContext.currentUser
      // 从库中获取邀请码，没有就生成一个插入库中
      var userModel = userDao.getById(currentUser)
      if (userModel.invitationCode.isNullOrEmpty()) {
          userModel.invitationCode = userDao.generateInvitationCode().toUpperCase()
          userModel.invitedCount = 0
          // 尝试更新，如果提示冲突，说明发生了并发问题，以库中已有为准。不过这能发生的前提是数据表针对invitation_code做了unique限制
          runCatching { userModel.updateById() }.exceptionOrNull()
              ?.takeIf { it.message?.contains("duplicate") == true }
              ?.run { userModel = userDao.getById(currentUser) }
      }

      // 查出一串记录，作为后面的计算依据
      val invitedHistory = invitationHistoryDao.getByInvitee(currentUser)
      val redeemHistory = invitationRedeemHistoryDao.listByRedeemer(currentUser)
      val subscriptionModel = subscriptionService.ktQuery().eq(SubscriptionModel::userId, currentUser).one()

      // 奖品构建：基本信息固定，只需填充兑换状态、是否可用（置灰状态）
      val awards = awardModels.map { InvitationInfoResponseDto.Award().fillWith(it) }.onEach { award ->
          award.redeemed = redeemHistory.any { it.awardId == award.id }
          // 常规case：邀请数够且未被兑换，则高亮。否则置灰
          award.enable = (userModel.invitedCount!! >= award.triggerCount!!) && !award.redeemed!!
      }
      val standardAward = awards.single { it.membershipLevel == MembershipLevel.STANDARD }
      val premiumAward = awards.single { it.membershipLevel == MembershipLevel.PREMIUM }
      // 特殊case1：只要高级有效(要么购买要么兑换)，普通奖励就置灰
      if (subscriptionModel?.membershipLevel == MembershipLevel.PREMIUM) {
          standardAward.enable = false
      }

      // 构建完整的邀请信息
      return InvitationInfoResponseDto().apply {
          this.invitationCode = userModel.invitationCode
          this.invitedCount = userModel.invitedCount
          this.hasBeenInvited = invitedHistory != null
          this.awards = awards
      }
  }

fun getInvitationInfo(): InvitationInfoResponseDto {
      val currentUser = RequestContext.currentUser
      val (invitationCode, invitedCount) = getInvitationCodeAndInvitedCount(currentUser)
      val hasBeenInvited = hasBeenInvited(invitationHistoryDao.getByInvitee(currentUser))
      val awards = awardModels.map { InvitationInfoResponseDto.Award().fillWith(it) }
      fillAwardRedeemed(awards, invitationRedeemHistoryDao.listByRedeemer(currentUser))
      fillAwardEnable(awards, currentUser, invitedCount, subscriptionDao.getByUserId(currentUser))

      return InvitationInfoResponseDto().apply {
          this.invitationCode = invitationCode
          this.invitedCount = invitedCount
          this.hasBeenInvited = hasBeenInvited
          this.awards = awards
      }
  }

  fun getInvitationCodeAndInvitedCount(userId: Int): Pair<String, Int> {
      var userModel = userDao.getById(userId)!!
      if (userModel.invitationCode.isNullOrEmpty()) {
          userModel.invitationCode = generateCode()
          userModel.invitedCount = 0
          // 尝试更新，如果提示冲突，说明发生了并发问题，以库中已有为准。前提：invitation_code做了unique限制
          try {
              userDao.updateById(userModel)
          } catch (_: DuplicateKeyException) {
              userModel = userDao.getById(userId)!!
          }
      }
      return userModel.invitationCode!! to userModel.invitedCount!!
  }

  fun generateCode(): String {
      val tryCount = 3
      (0..tryCount).forEach { _ ->
          val candidate = UUID.randomUUID().toString().takeLast(6).toUpperCase()
          if (userDao.getByInvitationCode(candidate) == null) {
              return candidate
          }
      }
      log.error("邀请码生成失败，请查找问题")
      throw ResponseException(ResErrCode.COMM_ERROR)
  }

  fun hasBeenInvited(invitationHistoryModel: InvitationHistoryModel?): Boolean {
      return invitationHistoryModel != null
  }

  fun fillAwardRedeemed(
      awards: List<InvitationInfoResponseDto.Award>, redeemHistory: List<InvitationRedeemHistoryModel>
  ) = awards.forEach { award ->
      award.redeemed = redeemHistory.any { it.awardId == award.id }
  }

  fun fillAwardEnable(
      awards: List<InvitationInfoResponseDto.Award>, userId: Int, invitedCount: Int, subscription: SubscriptionModel?
  ) {
      awards.forEach { award ->
          award.enable = (invitedCount >= award.triggerCount!!) && !award.redeemed!!
      }
      val standardAward = awards.single { it.membershipLevel == MembershipLevel.STANDARD }
      // 特殊case1：只要高级有效(要么购买要么兑换)，普通奖励就置灰
      if (subscription?.membershipLevel == MembershipLevel.PREMIUM) {
          standardAward.enable = false
      }
  }

abstract class RepositoryIntegrityTest<M : BaseMapper<T>, T> {

    /**
     * 非空且无默认值的字段
     */
    abstract val nonNullableWithoutDefaultValueFields: List<KMutableProperty<*>>

    /**
     * 可空或有默认值的字段
     */
    abstract val nullableOrDefaultFields: Map<KMutableProperty<*>, Any?>

    /**
     * 唯一索引列表和测试它们的数据（当存在多个唯一索引时，测试数据不好造，还是交给实现类比较好）
     */
    abstract val uniqueIndexesWithTestData: Map<List<KMutableProperty<*>>, List<T>>

    abstract fun getDao(): ServiceImpl<M, T>

    /**
     * 提供一个所有字段都不为空的基础model，用于测试
     */
    abstract fun createModelWithAllFieldNotNull(): T

    @Test
    fun `validate when field absent (without default value)`() {
        assertAll {
            nonNullableWithoutDefaultValueFields.forEach { prop ->
                // 待测字段填充null
                val mockModel = createModelWithAllFieldNotNull().apply { prop.setter.call(this, null) }
                // 填充null的字段都有应该报错
                val result = Result.runCatching { getDao().save(mockModel) }
                assertThat(result, prop.name).isFailure().matchesPredicate {
                    val nameInDb = StringUtils.camelToUnderline(prop.name)
                    it.message!!.contains("""null value in column "$nameInDb" violates not-null constraint""")
                }
            }
        }
    }

    @Test
    fun `validate when field absent (with default value)`() {
        // 清空数据库
        clearTable()
        // 字段填充null
        val mockModel = createModelWithAllFieldNotNull().apply {
            nullableOrDefaultFields.forEach { (prop, _) ->
                prop.setter.call(this, null)
            }
        }
        // 保存然后查出
        getDao().save(mockModel)
        val insertedModel = getDao().list().first()
        // 所有设置为null的字段查询结果都应该与预期的一致
        assertAll {
            nullableOrDefaultFields.forEach { (prop, expectedValue) ->
                if (expectedValue != null && expectedValue::class == Any::class) {
                    assertThat(prop.getter.call(insertedModel), prop.name).isNotNull()
                } else {
                    assertThat(prop.getter.call(insertedModel), prop.name).isEqualTo(expectedValue)
                }
            }
        }
    }

    @Test
    fun `validate unique constraint`() {
        clearTable()
        // 构建两个拥有一样字段值的对象
        assertAll {
            uniqueIndexesWithTestData.forEach { (index, testModels) ->
                val result = Result.runCatching { getDao().saveBatch(testModels) }
                assertThat(result, index.toString()).isFailure().isInstanceOf(DuplicateKeyException::class)
                    .matchesPredicate {
                        it.message!!.contains("already exists")
                    }
            }
        }
    }

    fun clearTable() {
        getDao().ktUpdate().remove()
    }

}

@RepositoryTest
class SeniorTest : RepositoryIntegrityTest<SeniorUserMapper, SeniorUserModel>() {

    @Autowired
    private lateinit var seniorUserDao: SeniorUserDao

    override val nonNullableWithoutDefaultValueFields: List<KMutableProperty<*>> = listOf(
        SeniorUserModel::id
    )

    override val nullableOrDefaultFields: Map<KMutableProperty<*>, Any?> = mapOf(
        SeniorUserModel::createdTime to Any(),
        SeniorUserModel::updatedTime to Any(),
        SeniorUserModel::redeemed to false
    )

    override val uniqueIndexesWithTestData: Map<List<KMutableProperty<*>>, List<SeniorUserModel>> = mapOf(
        listOf(SeniorUserModel::id) to listOf(createModelWithAllFieldNotNull(), createModelWithAllFieldNotNull())
    )

    override fun getDao(): ServiceImpl<SeniorUserMapper, SeniorUserModel> {
        return seniorUserDao
    }

    final override fun createModelWithAllFieldNotNull(): SeniorUserModel {
        return SeniorUserModel().apply {
            this.id = MOCK_USER_ID.toLong()
            this.createdTime = OffsetDateTime.now()
            this.updatedTime = OffsetDateTime.now()
            this.redeemed = false
        }
    }
}

@Test
fun `test update user info partially`() {
  // 清空表
  clearTable()
  // 构建测试数据
  val oldModel = createModelWithAllFieldNotNull()
  userDao.save(oldModel)

  // 调用被测SQL方法
  val mockUserId = MOCK_USER_ID
  val mockUserName = MOCK_USER_NAME + "gt"
  val mockRequest = UserUpdateReq().apply {
    this.name = mockUserName
  }
  userDao.updateUserInfo(mockUserId, mockRequest)
  // 取出数据
  val newModel = userDao.getById(mockUserId)
	// 判断结果
  assertThat(newModel.id).isEqualTo(mockUserId)
  assertThat(newModel.name).isEqualTo(mockRequest.name)
  assertThat(newModel.avatar).isEqualTo(oldModel.avatar)
  assertThat(newModel.description).isEqualTo(oldModel.description)
}

fun updateUserInfo(id: Int, request: UserUpdateReq): Boolean {
  return UserModel(
    id = id,
    name = request.name,
    avatar = request.avatar,
    description = request.description,
  ).run { updateById() }
}

fun lockUser(userId: Int) {
  ktQuery()
  .eq(UserModel::id, userId)
  .last("FOR UPDATE")
  .list()
}

// 事务管理器，直接注入即可
@Autowired
private lateinit var tm: DataSourceTransactionManager

@Test
fun `test lock user`() {
  // 注意latch的使用
  val latch = CountDownLatch(2)

  val transaction1 = Runnable {
    // 注意编程式事务的使用方式
    val transactionStatus = tm.getTransaction(TransactionDefinition.withDefaults())
    userDao.lockUser(MOCK_USER_ID)
    TimeUnit.SECONDS.sleep(2)
    tm.commit(transactionStatus)
    latch.countDown()
  }
  val transaction2 = Runnable {
    TimeUnit.SECONDS.sleep(1)
    val transactionStatus = tm.getTransaction(TransactionDefinition.withDefaults())
    try {
      assertThat {
        userDao.ktQuery().eq(UserModel::id, MOCK_USER_ID).last("FOR UPDATE NOWAIT").list()
      }.isFailure().isInstanceOf(CannotAcquireLockException::class)
    } finally {
      tm.commit(transactionStatus)
      latch.countDown()
    }
  }

  Thread(transaction1).start()
  Thread(transaction2).start()
  latch.await()
}